/**
 * 金牛座数据表文档生成工具 - 一键执行脚本
 * 
 * 功能：
 * - 生成表配置文件
 * - 生成表文档和类型定义
 * - 导出表数据到CSV（可选）
 */

import fs from 'fs';
import path from 'path';
import { execSync } from 'child_process';
import { fileURLToPath } from 'url';

// 获取当前文件目录
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// 命令行参数
const OFFLINE_MODE = process.argv.includes('--offline');
const USE_MOCK_TOKEN = process.argv.includes('--mock-token');
const REFRESH_TOKEN = process.argv.includes('--refresh-token');
const SKIP_CONFIG = process.argv.includes('--skip-config');
const EXPORT_CSV = process.argv.includes('--export-csv');
// API日志相关参数
const ENABLE_API_LOGGING = process.argv.includes('--log-api');
const CLEAR_API_LOGS = process.argv.includes('--clear-api-logs');

// 日志相关
const LOG_DIR = path.resolve(__dirname, '../logs');
const LOG_FILE = path.join(LOG_DIR, `generate-all-${new Date().toISOString().slice(0, 10)}.log`);
const API_LOG_FILE = path.join(LOG_DIR, 'api-requests.log');

// 创建日志目录
if (!fs.existsSync(LOG_DIR)) {
    fs.mkdirSync(LOG_DIR, { recursive: true });
}

// 清除API日志（如果指定）
if (CLEAR_API_LOGS && fs.existsSync(API_LOG_FILE)) {
    try {
        fs.writeFileSync(API_LOG_FILE, '', 'utf8');
        console.log(`API日志文件已清除: ${API_LOG_FILE}`);
    } catch (err) {
        console.error(`清除API日志文件失败: ${err.message}`);
    }
}

// 配置目录
const CONFIG_DIR = path.resolve(__dirname, '../config');
if (!fs.existsSync(CONFIG_DIR)) {
    fs.mkdirSync(CONFIG_DIR, { recursive: true });
}

// 缓存目录
const CACHE_DIR = path.resolve(__dirname, '../.cache');
if (!fs.existsSync(CACHE_DIR)) {
    fs.mkdirSync(CACHE_DIR, { recursive: true });
}

/**
 * 记录日志
 * @param {string} message 日志信息
 */
function log(message) {
    const timestamp = new Date().toISOString();
    const logMessage = `[${timestamp}] ${message}\n`;

    console.log(message);
    fs.appendFileSync(LOG_FILE, logMessage);
}

/**
 * 记录错误日志
 * @param {string} message 错误信息
 * @param {Error} error 错误对象
 */
function logError(message, error) {
    const timestamp = new Date().toISOString();
    let logMessage = `[${timestamp}] ERROR: ${message}\n`;

    if (error) {
        logMessage += `[${timestamp}] ERROR DETAILS: ${error.message}\n`;
        if (error.stack) {
            logMessage += `[${timestamp}] STACK: ${error.stack}\n`;
        }
    }

    console.error(message);
    if (error) console.error(error);

    fs.appendFileSync(LOG_FILE, logMessage);
}

/**
 * 执行命令
 * @param {string} command 要执行的命令
 * @param {Object} options 选项
 * @returns {string} 命令输出
 */
function executeCommand(command, options = {}) {
    try {
        log(`执行命令: ${command}`);
        const output = execSync(command, {
            stdio: ['pipe', 'pipe', 'pipe'],
            encoding: 'utf8',
            ...options
        });

        log(`命令执行成功`);
        return output;
    } catch (error) {
        logError(`命令执行失败: ${command}`, error);
        throw error;
    }
}

/**
 * 生成表配置文件
 */
function generateTableConfig() {
    try {
        log('步骤1: 生成表配置文件');
        log('注意: 所有API请求将使用x-token头进行认证');

        // 如果指定跳过配置生成，则检查配置文件是否存在
        if (SKIP_CONFIG) {
            const configFile = path.join(CONFIG_DIR, 'tables-config.json');
            if (fs.existsSync(configFile)) {
                log('跳过配置生成，使用现有配置文件');
                return;
            }
            log('配置文件不存在，将继续生成配置');
        }

        // 构建命令
        let command = `node ${path.join(__dirname, 'generateTableConfig.js')} generate`;
        if (OFFLINE_MODE) command += ' --offline';
        if (USE_MOCK_TOKEN) command += ' --mock-token';
        if (REFRESH_TOKEN) command += ' --refresh-token';
        // 添加API日志记录参数
        if (ENABLE_API_LOGGING) command += ' --log-api';
        if (CLEAR_API_LOGS) command += ' --clear-api-logs';

        // 检查是否需要指定schema
        const schemaIndex = process.argv.indexOf('--schema');
        if (schemaIndex > -1 && schemaIndex < process.argv.length - 1) {
            command += ` --schema ${process.argv[schemaIndex + 1]}`;
        }

        // 执行命令
        const output = executeCommand(command);
        log(output || '配置文件生成完成');
    } catch (error) {
        logError('生成表配置失败', error);
        throw error;
    }
}

/**
 * 生成表文档和类型定义
 */
function generateTableDocs() {
    try {
        log('步骤2: 生成表文档和类型定义');
        log('注意: 所有API请求将使用x-token头进行认证');

        // 构建命令
        let command = `node ${path.join(__dirname, 'generateTableDocs.js')}`;
        if (OFFLINE_MODE) command += ' --offline';
        if (USE_MOCK_TOKEN) command += ' --mock-token';
        if (REFRESH_TOKEN) command += ' --refresh-token';
        // 添加API日志记录参数
        if (ENABLE_API_LOGGING) command += ' --log-api';
        if (CLEAR_API_LOGS) command += ' --clear-api-logs';

        // 检查是否需要指定schema
        const schemaIndex = process.argv.indexOf('--schema');
        if (schemaIndex > -1 && schemaIndex < process.argv.length - 1) {
            command += ` --schema ${process.argv[schemaIndex + 1]}`;
        }

        // 执行命令
        const output = executeCommand(command);
        log('表文档生成完成');
    } catch (error) {
        logError('生成表文档失败', error);
        throw error;
    }
}

/**
 * 导出表数据到CSV
 */
function exportTablesToCSV() {
    try {
        log('步骤3: 导出表数据到CSV');

        // 获取原始数据目录
        const rawDataDir = path.resolve(__dirname, '../raw-data');
        const metadataDir = path.join(rawDataDir, 'metadata');

        // 检查是否有表汇总信息
        const tablesSummaryFile = path.join(metadataDir, 'tables_summary.json');
        if (!fs.existsSync(tablesSummaryFile)) {
            log('没有找到表汇总信息，跳过CSV导出');
            return;
        }

        // 读取表汇总信息
        const tablesSummary = JSON.parse(fs.readFileSync(tablesSummaryFile, 'utf8'));
        log(`开始导出 ${tablesSummary.length} 个表的数据为CSV`);

        // 创建CSV目录
        const csvDir = path.join(rawDataDir, 'csv');
        if (!fs.existsSync(csvDir)) {
            fs.mkdirSync(csvDir, { recursive: true });
        }

        // 导出每个表的数据
        const exportResults = [];
        for (const table of tablesSummary) {
            const tableName = table.tableName;
            const columnsFile = path.join(rawDataDir, tableName, 'columns.json');

            if (fs.existsSync(columnsFile)) {
                try {
                    // 读取列数据
                    const columns = JSON.parse(fs.readFileSync(columnsFile, 'utf8'));

                    // 创建CSV内容
                    const headers = Object.keys(columns[0] || {});
                    let csvContent = headers.join(',') + '\n';

                    // 添加每一行数据
                    columns.forEach(column => {
                        const row = headers.map(header => {
                            const val = column[header];

                            // 处理特殊字符
                            if (val === null || val === undefined) return '';
                            const strVal = String(val).replace(/"/g, '""');
                            return /[,\n"]/.test(strVal) ? `"${strVal}"` : strVal;
                        });

                        csvContent += row.join(',') + '\n';
                    });

                    // 保存CSV文件
                    const csvFilePath = path.join(csvDir, `${tableName}_columns.csv`);
                    fs.writeFileSync(csvFilePath, csvContent);
                    log(`表 ${tableName} 的列数据已导出到 ${csvFilePath}`);

                    exportResults.push({
                        tableName,
                        columnsFile: csvFilePath,
                        columnsCount: columns.length
                    });
                } catch (error) {
                    logError(`导出表 ${tableName} 的列数据失败`, error);
                }
            }
        }

        // 保存导出结果
        const exportSummaryFile = path.join(metadataDir, 'export_summary.json');
        fs.writeFileSync(
            exportSummaryFile,
            JSON.stringify({
                timestamp: new Date().toISOString(),
                tablesCount: tablesSummary.length,
                exportedCount: exportResults.length,
                exportResults
            }, null, 2)
        );

        log(`CSV导出完成，共导出 ${exportResults.length} 个表的数据`);
    } catch (error) {
        logError('导出表数据到CSV失败', error);
    }
}

/**
 * 主函数
 */
async function main() {
    try {
        log('=================================================');
        log('金牛座数据表文档生成工具 开始执行');
        log(`时间: ${new Date().toISOString()}`);
        log('=================================================');

        // 1. 生成表配置文件
        generateTableConfig();

        // 2. 生成表文档和类型定义
        generateTableDocs();

        // 3. 导出表数据到CSV（如果指定）
        if (EXPORT_CSV) {
            exportTablesToCSV();
        } else {
            log('步骤3: 跳过导出表数据到CSV');
        }

        log('=================================================');
        log('金牛座数据表文档生成工具 执行完成');
        log(`时间: ${new Date().toISOString()}`);
        log('请查看日志获取详细信息');
        log('=================================================');
    } catch (error) {
        logError('执行过程中发生错误', error);
        process.exit(1);
    }
}

// 执行主函数
main(); 